package com.delio.client.produccion.detallepedidos;

import java.util.List;

import com.extjs.gxt.ui.client.data.BaseFilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.BaseListLoader;
import com.extjs.gxt.ui.client.data.BasePagingLoadConfig;
import com.extjs.gxt.ui.client.data.BasePagingLoader;
import com.extjs.gxt.ui.client.data.BeanModelReader;
import com.extjs.gxt.ui.client.data.FilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.ListLoadResult;
import com.extjs.gxt.ui.client.data.ListLoader;
import com.extjs.gxt.ui.client.data.ModelData;
import com.extjs.gxt.ui.client.data.PagingLoadResult;
import com.extjs.gxt.ui.client.data.PagingLoader;
import com.extjs.gxt.ui.client.data.RpcProxy;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;

public class DetallePedidos {
	private static DetallePedidoServiceAsync dps = GWT.create(DetallePedidoService.class);
    public static ListStore<ModelData> store;
    public static ListStore<ModelData> storeCombo;
    public static PagingLoader<PagingLoadResult<ModelData>> loader;
    public static ListLoader<ListLoadResult<ModelData>> loaderCombo;
	public static Integer pedido_id;
	public static Integer detallepedido_id;
	
	public static void getPaginate() {
			RpcProxy<PagingLoadResult<DetallePedido>> proxy = new RpcProxy<PagingLoadResult<DetallePedido>>() {

				@Override
				protected void load(Object loadConfig,
				    AsyncCallback<PagingLoadResult<DetallePedido>> callback) {
					dps.paginateDetallePedido((FilterPagingLoadConfig) loadConfig, pedido_id, callback);
				}  
		    };
		    loader = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy, new BeanModelReader()){  
		        @Override  
		        protected Object newLoadConfig() {  
		          BasePagingLoadConfig config = new BaseFilterPagingLoadConfig();  
		          return config;  
		        }  
		      };  
	        loader.setRemoteSort(true);  
	        store = new ListStore<ModelData>(loader);
	 }
	 
	 
	public static void getStore(){
			
		 RpcProxy<List<DetallePedido>> proxy = new RpcProxy<List<DetallePedido>>(){
		    protected void load(Object loadConfig, AsyncCallback<List<DetallePedido>> callback){
			    dps.ListarDetallePedidos(callback);
			 }
		  	};
		 loaderCombo = new BaseListLoader<ListLoadResult<ModelData>>(proxy, new BeanModelReader());
		 storeCombo = new ListStore<ModelData>(loaderCombo);
		 loaderCombo.load();
		  
	}
	
	/* public static void listardireccioncliente(){
	    	System.out.println("el id del pedido es"+ pedido_id);
	      RpcProxy<List<DireccionCliente>> proxy = new RpcProxy<List<DireccionCliente>>(){
			    protected void load(Object loadConfig, AsyncCallback<List<DireccionCliente>> callback){
			       dps.ListarDetallePedidos(pedido_id, callback);
				 }
			  	};
		  	loader = BaseListLoader<ListLoadResult<BeanModel>>(proxy, new BeanModelReader());  
		    store = new ListStore<BeanModel>(loader);
	  	}*/    
	    
	    public static void listardireccionclienteCombo(){
	      RpcProxy<List<DetallePedido>> proxy = new RpcProxy<List<DetallePedido>>(){
	    		    protected void load(Object loadConfig, AsyncCallback<List<DetallePedido>> callback){
	    		       dps.ListarDetallePedidos(callback);
	    			 }
	    		  	};
	    	  	loaderCombo = new BaseListLoader<ListLoadResult<ModelData>>(proxy, new BeanModelReader());  
	    	    storeCombo = new ListStore<ModelData>(loaderCombo);	
	      
	    }
	    
		public static void guardar(final DetallePedido dp){
		 dps.guardar(dp, new AsyncCallback<Boolean>(){

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert("Error", "No pudo guardar", null);			
			}

			@Override
			public void onSuccess(Boolean result) {
	           if(!result)
	           	MessageBox.alert("Error", "No se guardo correctamente", null);
			}
		 });
	   }
	  
		public static void actualizar(DetallePedido dp){
		 dps.actualizar(dp, new AsyncCallback<Boolean>(){

		   @Override
		   public void onFailure(Throwable caught) {
			   MessageBox.alert("Error", "Error en la acutalizacion", null);	 
		   }	
			 
		   public void onSuccess(Boolean result){
			 if(result){
			   MessageBox.alert("Actualizado","Se actualizo Correctamente", null);
			 }else{
			   MessageBox.alert("Error", "No se actualizo Correctamente", null);	 
			 }
			}

		 });
	 }
	 
	 public static void eliminar(Integer id){
	     dps.eliminar(id, new AsyncCallback<Boolean>(){
			
			 @Override
			 public void onFailure(Throwable caught){
				 MessageBox.alert("Error", "Error en la Eliminacion", null);
			 }
			 
			 public void onSuccess(Boolean result){
				 if(result){
				   MessageBox.alert("Eliminado","Se elimino Correctamente", null); 
				 }else{
				   MessageBox.alert("Error", "No se elimino Correctamente", null);	 
				 } 
			 }

		 });
	 }
}
